The Rust Programming Language: Foundations of Heap-Allocated Collections

The Architecture of Growth

Rust’s collections, such as Vec<T> and String, are not primitive types; they are library-defined structures residing in the std module. This foundation dictates how Rust organizes data via the module system and manages memory through RAII (Resource Acquisition Is Initialization). While simple types live on the stack, collections utilize Heap Storage for dynamic growth, meaning their memory must be explicitly managed through the Drop trait.

Module Resolution & Visibility

The Rust compiler maps the module tree starting at the crate root (src/lib.rs or src/main.rs). A declaration like mod front_of_house; prompts the compiler to search for src/front_of_house.rs or src/front_of_house/mod.rs. Using pub modifiers and re-exports (pub use) allows encapsulated heap-allocated data to be safely interfaced through idiomatic paths.

As soon as a module’s scope ends, the Drop implementation automatically reclaims heap memory: $$Memory_{reclaimed} = \sum Drop(Elements)$$.

TERMINAL bash — 80x24

> Ready. Click "Run" to execute.

QUESTION 1

What happens if a project contains both src/module.rs and src/module/mod.rs?

The compiler prioritizes the directory style.

It triggers a compiler error due to ambiguity.

The files are merged automatically.

Rust ignores the .rs file.

QUESTION 2

How does RAII ensure memory safety in collections?

By using a background garbage collector.

By checking references at runtime.

By tying heap memory to the scope of the owner variable.

By keeping all data on the stack.

QUESTION 3

Which file is considered the 'anchor' for module resolution in a library crate?

src/main.rs

$src/lib.rs$

mod.rs

Cargo.toml

QUESTION 4

What is the purpose of the pub use statement?

To allocate memory on the heap.

To re-export a name to provide a more idiomatic public API.

To private-label a module.

To increase compilation speed.

QUESTION 5

Why can't Collections like Vec be stored entirely on the stack?

The stack cannot store integers.

They must have a fixed size known at compile time to stay on the stack.

The stack is too slow for collections.

Stack memory is never dropped.